Woah. I was not aware of that. @JeffBezanson, were you?

Btw, while we're on the subject, how do you feel about hex literals for unsigned ints? Feature or misfeature?

Do we genuinely not want octal literals? Is there something bad about them? Doesn't matter to me much either way, just curious if this is a real problem somehow.

They're probably not a real problem.
But most people don't expect to have their numbers behave differently because of leading zeroes and I assume nobody would miss octal literals.
R and Matlab don't have them, and besides calculating file access privileges, I don't think there is any use case for them.
Following the principle of least surprise I'd like to see them removed.

Re: hex
Honestly, I don't care much :) I rarely use hex literals, but they come in handy for the occasional bit twiddling.
More importantly, they are easy to distinguish visually, and are unlikely to be entered unknowingly.

Ok, I agree with that. Better to err on the side of fewer features. And if you really want octal parse_oct("377") works.

You might try a more explicit prefix for octal such as 0o. The leading zero is a weird C-ism that catches people not familiar with C off-guard, and octal doesn't really come up much in modern programming.

Re: hex, having hexadecimal floating-point syntax would be nice too. Hex floats are useful for precisely reading and writing float values as text.

Octal literals might be useful for functions which set filesystem permissions, e.g., chmod(path, 0755).

I agree that having octal literals could be useful if we were using a better prefix like 0o.

0o775 is pretty weird looking, but is better IMO than the dreaded 0755 traditional.

python3 decided to use 0o, while perl6 decided on 0c.

I think i'll go ahead and add 0o literals.

0o is certainly consistent with 0x and 0b. It's amusing how the only use of this is file permissions.

We could also just interpret the decimal value 755 as though it were octal when passing integers as permission masks.

We could also just interpret the decimal value 755 as though it were octal when passing integers as permission masks.

I like this, but I feel it also breaks away from most other programming language implementations. I know Python and C are both octal-based, are there any examples of programming languages that use decimal permissions? (If only there were a way to auto-detect and give the best of both worlds. :P )

Interpreting decimal values as though they were octal also has the issue that bitwise operations don't work right:

julia> 755 & 666
658

julia> oct(0o755 & 0o666)
"644"

Oof, yeah, that's a killer. I, personally, would expect bitwise operations to work when it comes to file permissions. Perhaps we should just let this one be, and make notes in the documentation that permissions should be passed as 0o755 literals, etc...

This is still a problem with BigInt, when it's given a string argument:

julia> BigInt(033)
33 # works as expected
julia> BigInt("033")
27 # doesn't; it was interpreted as octal.

Oh, that's not good at all. Thanks for point it out.